use std::process::Command;
use serde::{Deserialize, Serialize};
use serde_json::Value;
use super::env_path::get_full_path_from_script;

/// Kubectl版本信息响应结构
#[derive(Serialize, Deserialize)]
pub struct KubectlVersionResponse {
    /// 执行是否成功
    pub success: bool,
    /// 版本信息或错误信息
    pub data: KubectlVersionInfo,
    /// 错误信息（如果有）
    pub error: Option<String>,
}

/// Kubectl版本详细信息
#[derive(Serialize, Deserialize)]
pub struct KubectlVersionInfo {
    /// 客户端版本
    pub client_version: VersionDetail,
    /// 服务器版本（可选）
    pub server_version: Option<VersionDetail>,
}

/// 版本详情
#[derive(Serialize, Deserialize)]
pub struct VersionDetail {
    /// 主版本号
    pub major: String,
    /// 次版本号
    pub minor: String,
    /// git版本
    pub git_version: String,
    /// git提交
    pub git_commit: String,
    /// git树状态
    pub git_tree_state: String,
    /// 构建日期
    pub build_date: String,
    /// Go版本
    pub go_version: String,
    /// 编译器
    pub compiler: String,
    /// 平台
    pub platform: String,
}

fn result(message: String) -> KubectlVersionResponse {
    return KubectlVersionResponse {
        success: false,
        data: KubectlVersionInfo {
            client_version: VersionDetail {
                major: String::new(),
                minor: String::new(),
                git_version: String::new(),
                git_commit: String::new(),
                git_tree_state: String::new(),
                build_date: String::new(),
                go_version: String::new(),
                compiler: String::new(),
                platform: String::new(),
            },
            server_version: None,
        },
        error: Some(message),
    };
}

/// 获取Kubectl软件的版本信息
///
/// 获取本机的Kubectl软件版本信息
///
/// # 参数列表
///
/// # 返回结果
/// * `KubectlVersionResponse`  包含执行结果的结构体
#[tauri::command]
pub async fn get_kubectl_version() -> KubectlVersionResponse {
    // 通过shell脚本获取完整的PATH环境变量
    let path = get_full_path_from_script();
    
    match Command::new("kubectl")
        .env("PATH", &path)
        .arg("version")
        .arg("-o")
        .arg("json")
        .output() {
            Ok(output) => {
                if output.status.success() {
                    let version_output = String::from_utf8_lossy(&output.stdout).to_string();
                    
                    // 如果输出为空，返回错误
                    if version_output.trim().is_empty() {

                        return result("版本信息为空".to_string());
                    }
                    
                    match serde_json::from_str::<Value>(&version_output) {
                        Ok(json_value) => {
                            // 解析客户端版本信息
                            let client_version = parse_version_detail(&json_value, "clientVersion");
                            
                            // 解析服务器版本信息（如果存在）
                            let server_version = if json_value.get("serverVersion").is_some() {
                                Some(parse_version_detail(&json_value, "serverVersion"))
                            } else {
                                None
                            };
                            
                            let version_info = KubectlVersionInfo {
                                client_version,
                                server_version,
                            };
                            
                            KubectlVersionResponse {
                                success: true,
                                data: version_info,
                                error: None,
                            }
                        },
                        Err(parse_error) => {
                           result(format!("无法解析版本信息: {}", parse_error))
                        }
                    }
                } else {
                    let error_info = String::from_utf8_lossy(&output.stderr).to_string();
                   result(format!("执行错误: {}", error_info))
                }
            },
            Err(err) => {
                result(format!("执行错误: {}", err))
            }
        }
}

/// 解析版本详情
fn parse_version_detail(json_value: &Value, key: &str) -> VersionDetail {
    let version_obj = &json_value[key];
    
    VersionDetail {
        major: version_obj.get("major").and_then(|v| v.as_str()).unwrap_or("").to_string(),
        minor: version_obj.get("minor").and_then(|v| v.as_str()).unwrap_or("").to_string(),
        git_version: version_obj.get("gitVersion").and_then(|v| v.as_str()).unwrap_or("").to_string(),
        git_commit: version_obj.get("gitCommit").and_then(|v| v.as_str()).unwrap_or("").to_string(),
        git_tree_state: version_obj.get("gitTreeState").and_then(|v| v.as_str()).unwrap_or("").to_string(),
        build_date: version_obj.get("buildDate").and_then(|v| v.as_str()).unwrap_or("").to_string(),
        go_version: version_obj.get("goVersion").and_then(|v| v.as_str()).unwrap_or("").to_string(),
        compiler: version_obj.get("compiler").and_then(|v| v.as_str()).unwrap_or("").to_string(),
        platform: version_obj.get("platform").and_then(|v| v.as_str()).unwrap_or("").to_string(),
    }
}